import { defineStore } from "pinia";
import _common_util from "../util/common_util";
import { ElMessage } from "element-plus";
import common_util from "../util/common_util"; // 引入 ElMessage 用于提示

export const useCourseStore = defineStore("course", {
  state: () => ({
    courses: [],
    recommended: [],
    chooseCourse: {},
    courseResources: [],
    progress: 0,
    notes: [],
    questions: [],
    assignmentAnswer: "",
    chooseResource: {},
  }),

  getters: {},

  actions: {
    async getCourses() {
      _common_util.get("/api/courses", {}, (data) => {
        this.courses = data;
      });
    },
    async getRecommendedCourses() {
      _common_util.get("/api/courses/star5", {}, (data) => {
        this.recommended = data;
      });
    },
    fetchCourseDetail(courseId) {
      return new Promise((resolve, reject) => {
        _common_util.get(
          `/api/courses/${courseId}`,
          {},
          (data) => {
            // 根据API响应结构，提取course字段并合并老师信息
            if (data && data.course) {
              // 将老师信息合并到课程对象中
              this.chooseCourse = {
                ...data.course,
                teacherName: data.teacher ? data.teacher.name : '未知老师'
              };
              resolve(this.chooseCourse);
            } else {
              // 如果没有嵌套结构，直接使用data
              this.chooseCourse = data;
              resolve(data);
            }
          },
          (message, code) => {
            console.error(`获取课程详情失败 (ID: ${courseId}):`, message);
            reject(new Error(message));
          },
        );
      });
    },
    /**
 * @description 根据教师ID获取其创建的所有课程
 * @param {number} teacherId - 教师的用户ID
 * @returns {Promise<Array>} 返回一个包含课程列表的 Promise
 */
    fetchCoursesByTeacher(teacherId) {
      return new Promise((resolve, reject) => {
        // 确保 teacherId 有效
        if (!teacherId) {
          const errorMsg = "获取教师课程失败：必须提供教师ID";
          ElMessage.error(errorMsg);
          return reject(new Error(errorMsg));
        }

        _common_util.get(
          "/api/courses/by-teacher",
          { teacherId }, // 将 teacherId 作为查询参数
          (data) => {
            // 成功时，直接通过 Promise 返回课程数组
            resolve(Array.isArray(data) ? data : []);
          },
          (message) => {
            // 失败时，通过 Promise 返回错误
            ElMessage.error(`获取教师课程失败: ${message}`);
            reject(new Error(message));
          }
        );
      });
    },
    async getCourseDetail(courseId) {
      try {
        console.log("getCourseDetail", courseId);
        // 复用新的 action
        await this.fetchCourseDetail(courseId);

        // 获取资源的逻辑保持不变
        _common_util.get(`/api/courses/${courseId}/resources`, {}, (data) => {
          this.courseResources = data;
        }, (error) => {
          console.error("获取课程资源失败:", error);
          this.courseResources = []; // 设置为空数组避免页面崩溃
          //ElMessage.error("获取课程资源失败，请稍后重试");
        });
      } catch (error) {
        console.error("获取课程详情或资源失败:", error);
        return null;
      }
    },
    updateProgress(userId, progress) {
      console.log("updateProgress", userId, progress);
      console.log("this.chooseResource", this.chooseResource);
      common_util.post(
        "/api/study/progress",
        {
          resourceId: this.chooseResource.id,
          userId: userId,
          watchedAt: progress,
        },
        {},
        (data) => { },
      );
    },
    getProgress(userId, resourceId) {
      common_util.get("/api/study/progress", { userId, resourceId }, (data) => {
        this.progress = data.watchedAt;
      });
    },
    getNotes(userId, courseId) {
      if (!userId || !courseId) {
        ElMessage.warning("参数错误：请提供用户ID和课程ID");
        return Promise.reject("参数错误");
      }

      return new Promise((resolve, reject) => {
        common_util.get(
          `/api/study/notes`,
          { userId, courseId },
          (data) => {
            this.notes = data;
            resolve(data);
          },
          (error) => {
            reject(error);
          }
        );
      });
    },
    addNote(content, userId, courseId) {
      if (!content || !content.trim()) {
        ElMessage.warning("笔记内容不能为空！");
        return Promise.reject("笔记内容不能为空");
      }

      if (!userId || !courseId) {
        ElMessage.warning("参数错误：请提供用户ID和课程ID");
        return Promise.reject("参数错误");
      }

      return new Promise((resolve, reject) => {
        common_util.post(
          "/api/study/note",
          {
            userId,
            courseId,
            content,
          },
          {},
          (data) => {
            ElMessage.success("笔记保存成功");
            resolve(data);
          },
          (error) => {
            reject(error);
          }
        );
      });
    },
    answerQuestion(content, userId, questionId) {
      if (!content || !content.trim()) {
        ElMessage.warning("回答内容不能为空！");
        return Promise.reject("回答内容不能为空");
      }

      if (!userId || !questionId) {
        ElMessage.warning("参数错误：请提供用户ID和问题ID");
        return Promise.reject("参数错误");
      }

      return new Promise((resolve, reject) => {
        common_util.post(
          "/api/study/answer",
          {
            userId,
            content,
            questionId,
          },
          {},
          (data) => {
            ElMessage.success("回答成功");
            resolve(data);
          },
          (error) => {
            reject(error);
          }
        );
      });
    },
    askQuestion(userId, courseId, content) {
      if (!content || !content.trim()) {
        ElMessage.warning("问题内容不能为空！");
        return Promise.reject("问题内容不能为空");
      }
      
      if (!userId || !courseId) {
        ElMessage.warning("参数错误：请提供用户ID和课程ID");
        return Promise.reject("参数错误");
      }

      return new Promise((resolve, reject) => {
        common_util.post(
          "/api/study/ask",
          {
            userId,
            courseId,
            content,
          },
          {},
          (data) => {
            ElMessage.success("问题提交成功");
            resolve(data);
          },
          (error) => {
            reject(error);
          }
        );
      });
    },
    getQuestionAndAnswers(userId, courseId) {
      if (!userId || !courseId) {
        ElMessage.warning("参数错误：请提供用户ID和课程ID");
        return Promise.reject("参数错误");
      }

      return new Promise((resolve, reject) => {
        common_util.get(
          `/api/study/question-answers`,
          { userId, courseId },
          (data) => {
            this.questions = data;
            resolve(data);
          },
          (error) => {
            reject(error);
          }
        );
      });
    },
    addAnswer(qaId, answerContent) {
      // 实际应用中，这里会调用API提交回答
      const qa = this.questions.find((q) => q.id === qaId);
      if (!qa || !answerContent.trim()) {
        console.log("请输入回答内容");
        return;
      }
      console.log(`回答已添加: Question ${qaId}, Answer: ${answerContent}`);

      const newAnswer = {
        id: Date.now(),
        content: answerContent,
        timestamp: new Date().toLocaleString(),
        answerer: {
          name: "张护士",
          avatar: "https://placeholder.pics/svg/40/DEDEDE/555555/用户",
          isInstructor: false,
        },
      };

      if (!qa.answers) {
        qa.answers = [];
      }
      qa.answers.push(newAnswer);
    },
    // 获取课程问答
    getCourseQAs(courseId) {
      return new Promise((resolve, reject) => {
        _common_util.get(
          '/api/study/question-answers',
          { courseId },
          (data) => {
            console.log('获取到的问答数据:', data);
            this.questions = Array.isArray(data) ? data : [];
            console.log('处理后的questions:', this.questions);
            resolve(this.questions);
          },
          (message) => {
            this.questions = [];
            reject(new Error(message));
          }
        );
      });
    },

    // 提交问题
    postQuestion(courseId, content) {
      return new Promise((resolve, reject) => {
        _common_util.post(
          '/api/study/ask',
          { courseId, content },
          {},
          (data) => {
            ElMessage.success('问题提交成功');
            // 提交成功后刷新问答
            this.getCourseQAs(courseId);
            resolve(data);
          },
          (message) => {
            ElMessage.error(`提交问题失败: ${message}`);
            reject(new Error(message));
          }
        );
      });
    },

    submitAssignment(answer) {
      this.assignmentAnswer = answer;
      // 实际应用中，这里会调用API提交作业
      console.log("作业已提交:", answer);
    },
    setActiveTab(tabName) {
      this.activeTab = tabName;
    },
    /**
     * 新增课程 (同时上传数据和可选的封面文件)
     * @param {object} courseJsonData - 包含课程文本信息的对象
     * @param {File} [coverFile] - 用户选择的封面文件 (可选)
     * @param {function} [onSuccess] - 成功回调
     */
    addCourse(courseJsonData, coverFile, onSuccess) {
      // 1. 在 action 内部创建 FormData
      const formData = new FormData();

      // 2. 将 JSON 数据的每个键值对添加到 FormData
      for (const key in courseJsonData) {
        if (
          Object.prototype.hasOwnProperty.call(courseJsonData, key) &&
          courseJsonData[key] !== null
        ) {
          formData.append(key, courseJsonData[key]);
        }
      }

      // 3. 如果有文件，也添加进去
      if (coverFile) {
        // 'coverUrl' 是您后端 @RequestParam 注解期望接收的文件字段名
        console.log("coverFile", coverFile);
        formData.append("coverFile", coverFile);
      }

      console.log("formData:", formData);
      // 4. 直接调用我们刚刚改造好的 post 方法
      _common_util.post(
        "/api/courses/upload",
        formData, // 直接传递 FormData 对象
        {},
        (data) => {
          ElMessage.success("课程新增成功！");
          this.getCourses(); // 刷新列表
          if (onSuccess) onSuccess(data);
        },
        (message) => {
          ElMessage.error(`新增课程失败: ${message}`);
        },
      );
    },

    /**
     * 编辑课程 (同时上传数据和可选的封面文件)
     * @param {number} courseId - 课程ID
     * @param {object} courseJsonData - 包含课程文本信息的对象
     * @param {File} [coverFile] - 用户选择的封面文件 (可选)
     * @param {function} [onSuccess] - 成功回调
     */
    updateCourse(courseId, courseJsonData, coverFile, onSuccess) {
      // 1. 创建 FormData 对象，用于混合发送数据和文件
      const formData = new FormData();

      // 2. 遍历 JSON 数据对象，将每个非空字段添加到 FormData 中
      // API 要求所有参数都可选，因此这里只添加有值的字段
      for (const key in courseJsonData) {
        if (
          Object.prototype.hasOwnProperty.call(courseJsonData, key) &&
          courseJsonData[key] !== null &&
          courseJsonData[key] !== undefined
        ) {
          formData.append(key, courseJsonData[key]);
        }
      }

      // 3. 如果用户上传了新的封面文件，则将其添加到 FormData
      if (coverFile) {
        // 根据后端接口，文件参数名通常是 'coverFile' 或 'file'
        // 此处参考 addCourse 的实现，使用 'coverFile'
        formData.append("coverFile", coverFile);
      }
      console.log("formData:", formData);
      _common_util.patch(
        `/api/courses/${courseId}`, // 请求的 URL，包含课程 ID
        formData, // 要发送的数据
        {}, // URL 查询参数，这里为空
        (data) => {
          // 成功回调
          ElMessage.success("课程更新成功！");
          this.getCourseDetail(courseId); // 成功后刷新当前课程的详细信息
          if (onSuccess) onSuccess(data);
        },
        (message) => {
          // 失败回调
          ElMessage.error(`更新课程失败: ${message}`);
        },
      );
    },

    /**
     * 下架（删除）课程
     * @param {number} courseId - 要下架的课程ID
     * @param {function} [onSuccess] - 成功后的回调函数
     */
    deleteCourse(courseId, onSuccess) {
      _common_util.delete(
        `/api/courses/${courseId}`,
        {},
        (data) => {
          ElMessage.success("课程下架成功！");
          if (onSuccess) onSuccess(data);
          this.getCourses(); // 下架成功后刷新课程列表
        },
        (message) => {
          ElMessage.error(`下架课程失败: ${message}`);
        },
      );
    },

    /**
     * 上传课程资源
     * @param {number} courseId - 课程ID
     * @param {FormData} formData - 包含 file, type, resourceName 的 FormData 对象
     * @param {function} [onSuccess] - 成功后的回调函数
     */
    uploadResource(courseId, formData, onSuccess) {
      // 使用通用的 post 方法，该方法已支持 multipart/form-data
      _common_util.post(
        `/api/courses/${courseId}/resources`, // API接口地址
        formData, // 包含文件和其他数据的 FormData 对象
        {}, // 无需URL参数
        (data) => {
          ElMessage.success("资源上传成功！");
          // 调用可选的成功回调函数
          if (onSuccess) onSuccess(data);

          // 上传成功后，刷新该课程的资源列表
          _common_util.get(`/api/courses/${courseId}/resources`, {}, (res) => {
            this.courseResources = res;
          }, (error) => {
            console.error("刷新课程资源失败:", error);
            ElMessage.warning("资源上传成功，但刷新列表失败");
          });
        },
        (message) => {
          ElMessage.error(`资源上传失败: ${message}`);
        },
      );
    },

    /**
     * 对课程进行点赞或点踩
     * @param {number} courseId - 课程ID
     * @param {number} userId - 用户ID (可选，后端会通过Token获取)
     * @param {number} favor - 1 代表点赞, 0 代表点踩
     * @param {function} [onSuccess] - 成功后的回调函数
     */
    favorCourse(courseId, userId, favor, onSuccess) {
      // 后端会通过Token自动获取userId，所以只传递必要的参数
      // 确保参数类型正确
      const params = {
        courseId: Number(courseId),
        favor: Number(favor)
      };

      console.log("点赞请求参数:", params);

      _common_util.post(
        "/api/courses/favor",
        {}, // 空的请求体
        params, // 作为URL查询参数
        (data) => {
          console.log("点赞成功:", data);
          ElMessage.success(data); // 后端直接返回了提示信息
          if (onSuccess) onSuccess(data);
        },
        (message) => {
          console.error("点赞失败:", message);
          ElMessage.error(`操作失败: ${message}`);
        },
      );
    },
  },
});
